home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / gnustuff / minix / libsrc~1.z / libsrc~1 / ioctl.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-12-28  |  6.7 KB  |  286 lines
  1. #define __SRC__
  2. #include "lib.h"
  3. #include <minix/const.h>
  4. #include <minix/com.h>
  5. #include <termio.h>
  6. #include <minix/screen.h>
  7. #include <minix/stboots.h>
  8. #include <errno.h>
  9.     
  10. #ifndef WANT_WENK_RS232
  11. static int o_ioctl();
  12.  
  13.     /* ioctl does termio emulation work, passes the rest to o_ioctl */
  14.     
  15. int ioctl(fd,command,term)
  16. int fd;
  17. int command;
  18. struct termio *term;
  19. {
  20.     int i;
  21.     int r;
  22.     char *cp;
  23.     struct sgttyb b;
  24.     struct tchars c;
  25.     unsigned short iflag, oflag, cflag, lflag, baud;
  26.     
  27.     
  28.     iflag = oflag = cflag = lflag = 0;
  29.     switch(command) {
  30.       case TCGETA:
  31.     if((r = o_ioctl(fd,TIOCGETP, &b)) < 0)
  32.         goto error;
  33.     if((r = o_ioctl(fd,TIOCGETC, &c)) < 0)
  34.         goto error;
  35.     for(cp=(char*)term,i=0;i<(int)sizeof(*term);i++)
  36.         *cp++ = 0;
  37.     if(b.sg_flags & RAW) { /* raw over rides */
  38.         iflag = 0;
  39.         cflag = CS8;
  40.         lflag = 0;
  41.         oflag = 0;
  42.     } else {
  43.         oflag = CR0|OPOST;
  44.         iflag = (BRKINT|IGNPAR|ISTRIP|IXON);
  45.         cflag = CS7|PARENB|CREAD;
  46.         lflag = 0;
  47.         if((b.sg_flags & CBREAK ) == 0)
  48.         lflag |= ICANON;
  49.         if(b.sg_flags & ECHO) 
  50.         lflag |= ECHO;
  51.         if(b.sg_flags & XTABS) 
  52.         oflag |= TAB3;
  53.         if(b.sg_flags & CRMOD) {
  54.         oflag |= ONLCR;
  55.         iflag |= ICRNL;
  56.         }
  57.     }
  58.     baud = b.sg_ispeed & 0xf;
  59.     cflag |= baud; 
  60.     term->c_iflag = iflag;
  61.     term->c_oflag = oflag;
  62.     term->c_cflag = cflag;
  63.     term->c_lflag = lflag;
  64.     term->c_cc[VINTR] = c.t_intrc;
  65.     term->c_cc[VQUIT] = c.t_quitc;
  66.     term->c_cc[VERASE] = b.sg_erase;
  67.     term->c_cc[VKILL] = b.sg_kill;
  68.     term->c_cc[VEOF] = c.t_eofc;
  69.     term->c_cc[VEOL] = '\0';
  70.     term->c_cc[VEOL2] = c.t_brkc? c.t_brkc: '\n';
  71.     break;
  72.  
  73.       case TCSETA:
  74.       case TCSETAW:
  75.       case TCSETAF:
  76.     for(cp=(char*)&b,i=0;i<(int)sizeof(b);i++)
  77.         *cp++ = 0;
  78.     for(cp=(char*)&c,i=0;i<(int)sizeof(c);i++)
  79.         *cp++ = 0;
  80.     if(((term->c_iflag & (BRKINT|IGNPAR|ISTRIP|IXON))== 0) && /* raw */
  81.        ((term->c_oflag & OPOST)==0) )
  82.         b.sg_flags |= RAW;
  83.     else {
  84.         if(term->c_oflag & (TAB3))
  85.         b.sg_flags |= XTABS;
  86.         if(term->c_lflag & ECHO)
  87.         b.sg_flags |= ECHO;
  88.         if((term->c_lflag & ICANON)==0)
  89.         b.sg_flags |= CBREAK;
  90.         
  91.         if(term->c_oflag & ONLCR || term->c_iflag & ICRNL)
  92.         b.sg_flags |= CRMOD;
  93.     }
  94.     baud = term->c_cflag & CBAUD;
  95.     b.sg_ispeed |= baud; 
  96.     
  97.     c.t_intrc = term->c_cc[VINTR];
  98.     c.t_quitc = term->c_cc[VQUIT];
  99.     b.sg_erase = term->c_cc[VERASE];
  100.     b.sg_kill = term->c_cc[VKILL];
  101.     c.t_eofc = term->c_cc[VEOF];
  102.     c.t_brkc = term->c_cc[VEOL];
  103.     c.t_startc = '\021'; /* ^Q */
  104.     c.t_stopc = '\023'; /* ^S */
  105.     
  106.     if((r = o_ioctl(fd,TIOCSETP, &b)) < 0)
  107.         goto error;
  108.     if((r = o_ioctl(fd,TIOCSETC, &c)) < 0)
  109.         goto error;
  110.     /* fall thru */
  111.  
  112.       case TCSBRK:
  113.       case TCFLSH:
  114.     r = o_ioctl(fd,command,(char*)0);
  115.     break;
  116.  
  117.       case TCXONC:  /* output if term=0 off, if term=1, on */
  118.  
  119.       default:
  120.     r = o_ioctl(fd,command,term);
  121.     break;
  122.     }
  123.     return(r);
  124.  
  125.   error:
  126.     return(r);
  127. }
  128. #endif
  129.  
  130.  
  131. #ifndef WANT_WENK_RS232
  132. PRIVATE int o_ioctl(fd, request, u)
  133. #else
  134. PUBLIC int ioctl(fd, request, u)
  135. #endif
  136. int fd;
  137. int request;
  138. union {
  139.     struct sgttyb *argp;
  140.     struct tchars *argt;
  141.     long arg;
  142.     struct scr_param *args1;
  143.     struct scr_palette *args2;
  144.     struct block0 *argsbs;
  145.     struct part   *argspart;
  146. } u;
  147.  
  148. {
  149.     int n;
  150.     long erase, kill, intr, quit, xon, xoff, eof, brk, speed;
  151. #ifdef WANT_WENK_RS232
  152.     int ispeed, ospeed;
  153. #endif
  154.     
  155.     M.TTY_REQUEST = request;
  156.     M.TTY_LINE = fd;
  157.     
  158.     switch(request) {
  159.       case TIOCSETP:
  160.     erase = u.argp->sg_erase & BYTE;
  161.     kill = u.argp->sg_kill & BYTE;
  162. #ifdef WANT_WENK_RS232
  163.     M.TTY_SPEK = (erase << 8) | kill;
  164.     M.TTY_FLAGS = u.argp->sg_flags;
  165.     M.TTY_FLAGS |= (( u.argp->sg_ospeed << 8 ) | u.argp->sg_ispeed ) << 16L;
  166. #else
  167.     speed = u.argp->sg_ispeed & 0377;
  168.     M.TTY_SPEK = (speed << 16) | (erase << 8) | kill;
  169.     M.TTY_FLAGS = u.argp->sg_flags;
  170. #endif
  171.     n = callx(FS, IOCTL);
  172.       return(n);
  173.     
  174.       case TIOCSETC:
  175.       intr = u.argt->t_intrc & BYTE;
  176.       quit = u.argt->t_quitc & BYTE;
  177.       xon  = u.argt->t_startc & BYTE;
  178.       xoff = u.argt->t_stopc & BYTE;
  179.       eof  = u.argt->t_eofc & BYTE;
  180.       brk  = u.argt->t_brkc & BYTE;        /* not used at the moment */
  181.       M.TTY_SPEK = (intr<<24) | (quit<<16) | (xon<<8) | (xoff<<0);
  182.       M.TTY_FLAGS = (eof<<8) | (brk<<0);
  183.       n = callx(FS, IOCTL);
  184.       return(n);
  185.       
  186.       case TIOCGETP:
  187.       n = callx(FS, IOCTL);
  188.     u.argp->sg_erase = (M.TTY_SPEK >> 8) & BYTE;
  189.     u.argp->sg_kill  = (M.TTY_SPEK >> 0) & BYTE;
  190. #ifdef WANT_WENK_RS232
  191.       u.argp->sg_flags = M.TTY_FLAGS;
  192.       u.argp->sg_ospeed = M.TTY_FLAGS >> 24;
  193.       u.argp->sg_ispeed = M.TTY_FLAGS >> 16;
  194. #else
  195.     u.argp->sg_ispeed  = (M.TTY_SPEK >> 16) & 0377;
  196.       u.argp->sg_flags = M.TTY_FLAGS;
  197. #endif
  198.       return(n);
  199.     
  200.       case TIOCGETC:
  201.       n = callx(FS, IOCTL);
  202.       u.argt->t_intrc  = (M.TTY_SPEK >> 24) & BYTE;
  203.       u.argt->t_quitc  = (M.TTY_SPEK >> 16) & BYTE;
  204.       u.argt->t_startc = (M.TTY_SPEK >>  8) & BYTE;
  205.       u.argt->t_stopc  = (M.TTY_SPEK >>  0) & BYTE;
  206.       u.argt->t_eofc   = (M.TTY_FLAGS >> 8) & BYTE;
  207.       u.argt->t_brkc   = (M.TTY_FLAGS >> 8) & BYTE;
  208.       return(n);
  209.     
  210.       case SCRSETPARAM:
  211.       case SCRGETPARAM:
  212.       case SCRSETCOLOR:
  213.       case SCRGETCOLOR:
  214.     M.TTY_SPEK = (long) u.args1;
  215.     n = callx(FS, IOCTL);
  216.     return(n);
  217.     
  218.     /* for disk-clock */
  219.       case DC_RBMS100:
  220.       case DC_RBMS200:
  221.       case DC_RSUPRA:
  222.       case DC_RICD:
  223.       case DC_WBMS100:
  224.       case DC_WBMS200:
  225.     M.TTY_SPEK = u.arg;  /* this is address to write ans to */
  226.     n = callx(FS, IOCTL);
  227.     return(n);
  228.  
  229.     /* for floppy/hard disk */
  230.       case DKGETP:    /* get struct block0 */
  231.     M.TTY_SPEK = (long)u.argsbs;
  232.     n = callx(FS, IOCTL);
  233.     return(n);
  234.       case DKPART:    /* get struct part */
  235.     M.TTY_SPEK = (long)u.argspart;
  236.     n = callx(FS, IOCTL);
  237.     return(n);
  238.       case DKOPEN:    /* open disk after a DKCLOSE */
  239.     M.TTY_SPEK = 0L;
  240.     n = callx(FS, IOCTL);
  241.     return(n);
  242.       case DKCLOSE:    /* close out disk */
  243.     M.TTY_SPEK = (long)0L;
  244.     n = callx(FS, IOCTL);
  245.     return(n);
  246.     
  247. #ifndef WANT_WENK_RS232
  248.       case TIOCSTART:
  249.     n = callx(FS, IOCTL);
  250.     return(n);
  251.     
  252.       case TIOCSTOP:
  253.     n = callx(FS, IOCTL);
  254.     return(n);
  255.     
  256.     /* taken from termio for rs232 */
  257.       case TCSETAW: /* wait for output to drain */
  258.       case TCSETAF: /* wait for output to dran, then flush input */
  259.       case TCSBRK:  /* drain output, send a break */
  260.       case TCXONC:  /* start/stop output arg ==0 stop, ==1 start */    
  261.       case TCFLSH:  /* flush: 0==input 1==output 2=both */
  262.     M.TTY_SPEK = u.arg & 0377;
  263.     n = callx(FS, IOCTL);
  264.     return(n);
  265.       case FIONREAD:  /* return num chars in read Q */
  266.       case TCFLOWON:
  267.       case TCFLOWOFF:
  268.       case TCFLOW:
  269.       case TCSETDTR:    /* arg ....xy; x=rts, y=dtr */
  270.     M.TTY_SPEK = u.arg;  /* this is address to write ans to */
  271.     n = callx(FS, IOCTL);
  272.     return(n);
  273.       case TCGETRS:
  274.     M.TTY_SPEK = u.arg;  /* this is address to write ans to */
  275.     n = callx(FS, IOCTL);
  276.     return(n);
  277. #endif
  278.     
  279.       default:
  280.     n = -1;
  281.     errno = (EINVAL);
  282.     return(n);
  283.     }
  284. }
  285.  
  286.